#else // _WIN32
		memmove( pvMem, Offs(dwOffset), dwSize); // Read
#endif // _WIN32
#else	//_PC
		memmove( pvMem, Offs(dwOffset), dwSize); // Read
#endif	//_PC
	}
	else {
		ASSERT(FALSE);
	}
	m_dwOffsetPointer += dwSize;
	return dwSize;
}

DWORD	GameMemory::Read(DWORD dwOffset, VOID* pvDestination, DWORD dwSize)
{
	return _ReadWrite(MV_READ, dwOffset, pvDestination, dwSize);
}

DWORD	GameMemory::Read(VOID* pvDestination, DWORD dwSize)
{
	return Read( m_dwOffsetPointer, pvDestination, dwSize);
}

DWORD	GameMemory::dwRead(BOOL	bBigEnd)
{
	return dwRead( m_dwOffsetPointer, bBigEnd);
}

WORD	GameMemory::wRead(BOOL	bBigEnd)
{
	return wRead( m_dwOffsetPointer, bBigEnd);
}

BYTE	GameMemory::byRead(VOID)
{
	return byRead( m_dwOffsetPointer);
}

DWORD	GameMemory::dwRead(DWORD dwOffset, BOOL	bBigEnd)
{
	DWORD	dwTemp;
	_ReadWrite(MV_READ, dwOffset, &dwTemp, sizeof(DWORD));
	DWORD	dwTemp1 = (DWORD)(dwTemp >> 24);
	DWORD	dwTemp2 = (DWORD)((dwTemp >> 8) & 0x0000ff00);
	DWORD	dwTemp3 = (DWORD)((dwTemp << 8) & 0x00ff0000);
	DWORD	dwTemp4 = (DWORD)(dwTemp << 24);
#ifdef	MAC
	return !bBigEnd ? (DWORD)(dwTemp1 | dwTemp2 | dwTemp3 | dwTemp4) : dwTemp;
#else
	return bBigEnd ? (DWORD)(dwTemp1 | dwTemp2 | dwTemp3 | dwTemp4) : dwTemp;
#endif
}

WORD	GameMemory::wRead(DWORD dwOffset, BOOL	bBigEnd)
{
	WORD	wTemp;
	_ReadWrite(MV_READ, dwOffset, &wTemp, sizeof(WORD));
	WORD wTemp1 = (WORD)(wTemp >> 8);
	WORD wTemp2 = (WORD)(wTemp << 8);
#ifdef	MAC
	return !bBigEnd ? (WORD)(wTemp1 | wTemp2) : wTemp;
#else
	return bBigEnd ? (WORD)(wTemp1|wTemp2) : wTemp;
#endif
}

BYTE	GameMemory::byRead(DWORD dwOffset)
{
	BYTE	byTemp;
	_ReadWrite(MV_READ, dwOffset, &byTemp, sizeof(BYTE));
	return byTemp;
}

DWORD	GameMemory::Write(DWORD dwOffset, VOID* pvSource, DWORD dwSize)
{
	return _ReadWrite(MV_WRITE, dwOffset, pvSource, dwSize);
}

DWORD	GameMemory::Write(VOID* pvSource, DWORD dwSize)
{
	return Write(m_dwOffsetPointer, pvSource, dwSize);
}

VOID	GameMemory::dwWrite(DWORD dwDWord, BOOL	bBigEnd)
{
	dwWrite(dwDWord, m_dwOffsetPointer, bBigEnd);
}

VOID	GameMemory::wWrite(WORD wWord, BOOL	bBigEnd)
{
	wWrite(wWord, m_dwOffsetPointer, bBigEnd);
}

VOID	GameMemory::byWrite(BYTE byByte)
{
	byWrite(byByte, m_dwOffsetPointer);
}

VOID	GameMemory::dwWrite(DWORD dwDWord, DWORD dwOffset, BOOL	bBigEnd)
{
	DWORD	dwTemp1 = (DWORD)(dwDWord >> 24);
	DWORD	dwTemp2 = (DWORD)((dwDWord >> 8) & 0x0000ff00);
	DWORD	dwTemp3 = (DWORD)((dwDWord << 8) & 0x00ff0000);
	DWORD	dwTemp4 = (DWORD)(dwDWord << 24);
#ifdef	MAC
	DWORD dwDWrite = !bBigEnd ? (DWORD)(dwTemp1 | dwTemp2 | dwTemp3 | dwTemp4) : dwDWord;
#else
	DWORD dwDWrite = bBigEnd ? (DWORD)(dwTemp1 | dwTemp2 | dwTemp3 | dwTemp4) : dwDWord;
#endif
	_ReadWrite(MV_WRITE, dwOffset, &dwDWrite, sizeof(DWORD));
}

VOID	GameMemory::wWrite(WORD wWord, DWORD dwOffset, BOOL	bBigEnd)
{
	WORD wTemp1 = (WORD)(wWord >> 8);
	WORD wTemp2 = (WORD)(wWord << 8);
#ifdef	MAC
	WORD	wWrite = !bBigEnd ? (WORD)(wTemp1 | wTemp2) : wWord;
#else
	WORD	wWrite = bBigEnd ? (WORD)(wTemp1| wTemp2) : wWord;
#endif
	_ReadWrite(MV_WRITE, dwOffset, &wWrite, sizeof(WORD));
}

VOID	GameMemory::byWrite(BYTE byByte, DWORD dwOffset)
{
	_ReadWrite(MV_WRITE, dwOffset, &byByte, sizeof(BYTE));
}

VOID	Memset(GameMemory& mMemory, DWORD dwOffset, DWORD dwSize, BYTE byData)
{
	if ( (dwSize + dwOffset) > mMemory.GetAllocSize() ) {
		ASSERT(FALSE);
		dwSize = mMemory.GetAllocSize() - dwOffset;
	}
#if defined( _PC )
#if defined( _WIN32 )
	FillMemory( mMemory.Offs(dwOffset), dwSize, byData);
#else // WIN32
	memset(mMemory.Offs(dwOffset), dwSize, byData);
#endif // _WIN32
#else	// _PC
	memset(mMemory.Offs(dwOffset), dwSize, byData);
#endif	// _PC
}

VOID	Memmov(GameMemory& mSource, DWORD dwSourceOffset, GameMemory& mDestination, DWORD dwDestinationOffset, DWORD dwSize)
{
	if ( mDestination.GetAllocSize() < (dwDestinationOffset + dwSize) ) {
		ASSERT(FALSE);
		dwSize = mDestination.GetAllocSize() - dwDestinationOffset;
	}
	if ( mSource.GetAllocSize() < (dwSourceOffset + dwSize) ) {
		ASSERT(FALSE);
		dwSize = mSource.GetAllocSize() - dwSourceOffset;
	}
#if defined(_PC)
#if defined( _WIN32 )
	CopyMemory( mDestination.Offs(dwDestinationOffset), mSource.Offs(dwSourceOffset), dwSize);
#else // _WIN32
	memmove(mDestination.Offs(dwDestinationOffset), mSource.Offs(dwSourceOffset), dwSize);
#endif // _WIN32
#else	//_PC
	memmove(mDestination.Offs(dwDestinationOffset), mSource.Offs(dwSourceOffset), dwSize);
#endif	//_PC
}